#include <iostream>
//
//using namespace std;
//
//int pre[1000005];
//int cnt = 0;
//
//int find(int x) {
//    if (x != pre[x]) {
//        pre[x] = find(pre[x]);
//    }
//    return pre[x];
//}
//
//void merge(int a, int b) {
//    int ao = find(a);
//    int bo = find(b);
//    if (ao != bo) {
//        pre[ao] = bo;
//        cnt--;
//    }
//}
//
//int main() {
//    int m, n, k;
//    cin >> m >> n >> k;
//    cnt = m * n;
//    for (int i = 0; i <= m*n; i++)
//    {
//        pre[i] = i;
//    }
//    for (int i = 0; i < k; i++)
//    {
//        int a, b;
//        cin >> a >> b;
//        merge(a, b);
//    }
//    cout << cnt;
//    return 0;
//}
//

#include "iostream"
#include "vector"
#include "unordered_map"
#include "unordered_set"
#include "algorithm"
#include "string"
#include "list"
#include "string.h"



class OneLoop {
public:

    std::unordered_map<int,std::list<int>> set_id_to_childs;
    std::unordered_map<int,int> child_to_set_id;
    std::unordered_map<int,char> tag;
    bool run(int a,int b,int c
    ) {

        for(int i=0;i<c;i++){
            int n,m;std::cin>>n>>m;

            tag[m]=1;
            tag[n]=1;
            auto n_nf=child_to_set_id.find(n)==child_to_set_id.end();
            auto m_nf=child_to_set_id.find(m)==child_to_set_id.end();
            if(n_nf&&m_nf
                ){
                set_id_to_childs[n]=std::list<int>();
                auto &wp=set_id_to_childs[n];
                wp.push_back(n);wp.push_back(m);
                if(m==414||n==414){
                    printf("");
                }
                child_to_set_id[n]=n;
                child_to_set_id[m]=n;
            }else if(!n_nf&&m_nf){
                auto setid=child_to_set_id[n];
                set_id_to_childs[setid].push_back(m);
                if(m==414){
                    printf("");
                }
                child_to_set_id[m]=setid;
            }else if(!m_nf&&n_nf){
                auto setid=child_to_set_id[m];
                set_id_to_childs[setid].push_back(n);
                if(n==414){
                    printf("");
                }
                child_to_set_id[n]=setid;
            }else{
                auto setidm=child_to_set_id[m];
                auto setidn=child_to_set_id[n];
                if(setidm!=setidn){
                    auto mchild=set_id_to_childs[setidm];
                    for(auto ch:mchild){
                        if(ch==414){
                            printf("");
                        }
                        child_to_set_id[ch]=setidn;
                    }
                    auto &setl=set_id_to_childs[setidn];

                    if(mchild.size()>0){
                        setl.splice(setl.end(),mchild);
                    }
//                    setl.merge(mchild);
                    set_id_to_childs.erase(setidm);
                }
            }
        }
        int cnt=0;
        for(int i=1;i<=a*b;i++){
            if(child_to_set_id.find(i)==child_to_set_id.end()){
                cnt++;
            }
        }
        printf("%d",set_id_to_childs.size()+cnt);
        return true;
    }
};

class Solution {
public:
    void run() {

        bool first = true;
        int a, b, c, d, e;
        //        std::cin >> a;

        while (std::cin>>a>>b>>c) {

            OneLoop l;
            if (!l.run(a,b,c)) {
                //                return;
            }
        }


    }
};

int main() {
    //    bool cur_num= true;
    Solution().run();
    return 0;
}

